(function(_scope){
  
  /*
   * pi.js
   * 1.0
   * Azer Koçulu <http://azer.kodfabrik.com>
   * http://pi-js.googlecode.com
   */
  
  _scope.pi = Object(3.14159265358979323846);
  var pi  = _scope.pi;
  pi.version = 1.0;
  
  pi.env = {
    ie: /MSIE/i.test(navigator.userAgent),
    ie6: /MSIE 6/i.test(navigator.userAgent),
    ie7: /MSIE 7/i.test(navigator.userAgent),
    ie8: /MSIE 8/i.test(navigator.userAgent),
    firefox: /Firefox/i.test(navigator.userAgent),
    opera: /Opera/i.test(navigator.userAgent),
    webkit: /Webkit/i.test(navigator.userAgent)
  };
  
  pi.util = {
    IsArray:function(_object){
      return _object && _object != window && ( _object instanceof Array || ( typeof _object.length == "number" && typeof _object.item =="function" ) )
    },
    IsHash:function(_object){
      return _object && typeof _object=="object"&&(_object==window||_object instanceof Object)&&!_object.nodeName&&!pi.util.IsArray(_object)
    },
    DOMContentLoaded:[],
    AddEvent: function(_element,_eventName,_fn,_useCapture){
      _element[pi.env.ie.toggle("attachEvent","addEventListener")](pi.env.ie.toggle("on","")+_eventName,_fn,_useCapture||false);
      return pi.util.AddEvent.curry(this,_element);
    },
    RemoveEvent: function(_element,_eventName,_fn,_useCapture){
      return _element[pi.env.ie.toggle("detachEvent","removeEventListener")](pi.env.ie.toggle("on","")+_eventName,_fn,_useCapture||false);
    },
    GetWindowSize:function(){
      return {
        height:pi.env.ie?Math.max(document.documentElement.clientHeight,document.body.clientHeight):window.innerHeight,
        width:pi.env.ie?Math.max(document.documentElement.clientWidth,document.body.clientWidth):window.innerWidth
      }
    },
    Include:function(_url,_callback){
      var script = new pi.element("script").attribute.set("src",_url), callback = _callback||new Function, done = false, head = pi.get.byTag("head")[0];
      script.environment.getElement().onload = script.environment.getElement().onreadystatechange = function(){
        if(!done && (!this.readyState || this.readyState == "loaded" || this.readyState == "complete")){
          callback.call(this);
          done = true;
          head.removeChild(script.environment.getElement());
        }
      };
      script.insert(head);
    },
    Element:{
      addClass:function(_element,_class){
        if( !pi.util.Element.hasClass(_element,_class) )
          pi.util.Element.setClass(_element, pi.util.Element.getClass(_element) + " " + _class );
      },
      getClass:function(_element){
        return _element.getAttribute(pi.env.ie.toggle("className","class"))||"";
      },
      hasClass:function(_element,_class){
        return pi.util.Element.getClass(_element).split(" ").indexOf(_class)>-1;
      },
      removeClass:function(_element,_class){
        if( pi.util.Element.hasClass(_element,_class) )
          pi.util.Element.setClass(
            _element, 
            pi.util.Element.getClass(_element,_class).split(" ").removeValue(_class).join(" ")
          );
      },
      setClass:function(_element,_value){
        _element.setAttribute( pi.env.ie.toggle("className","class"), _value );
      },
      toggleClass:function(){
        if(pi.util.Element.hasClass.apply(this,arguments))
          pi.util.Element.removeClass.apply(this,arguments);
        else
          pi.util.Element.addClass.apply(this,arguments);
      },
      getOpacity:function(_styleObject){
        var styleObject = _styleObject;
        if(!pi.env.ie)
          return styleObject["opacity"];
          
        var alpha = styleObject["filter"].match(/opacity\=(\d+)/i);
        return alpha?alpha[1]/100:1;
      },
      setOpacity:function(_element,_value){
        if(!pi.env.ie)
          return pi.util.Element.addStyle(_element,{ "opacity":_value });
        _value*=100;
        pi.util.Element.addStyle(_element,{ "filter":"alpha(opacity="+_value+")" });
        return this._parent_;
      },
      getPosition:function(_element){
        var parent = _element,offsetLeft = 0, offsetTop = 0, view = pi.util.Element.getView(_element);
        while(parent&&parent!=document.body&&parent!=document.firstChild){
          offsetLeft +=parseInt(parent.offsetLeft);
          offsetTop += parseInt(parent.offsetTop);
          parent = parent.offsetParent;
        };
        return {
          "bottom":view["bottom"],
          "left":view["left"],
          "marginTop":view["marginTop"],
          "marginLeft":view["marginLeft"],
          "offsetLeft":offsetLeft,
          "offsetTop":offsetTop,
          "position":view["position"],
          "right":view["right"],
          "top":view["top"],
          "z-index":view["zIndex"]
        };
      },
      getSize:function(_element){
        var view = pi.util.Element.getView(_element);
        return {
          "height":view["height"],
          "offsetHeight":_element.offsetHeight,
          "offsetWidth":_element.offsetWidth,
          "width":view["width"]
        }
      },
      addStyle:function(_element,_style){
        for(var key in _style){
          key = key=="float"?pi.env.ie.toggle("styleFloat","cssFloat"):key;
          if (key == "opacity" && pi.env.ie) {
            pi.util.Element.setOpacity(_element,_style[key]);
            continue;
          }
          _element.style[key] = _style[key];
        }
      },
      getStyle:function(_element,_property){
        _property = _property=="float"?pi.env.ie.toggle("styleFloat","cssFloat"):_property;
        if(_property=="opacity"&&pi.env.ie)
          return pi.util.Element.getOpacity(_element.style);
        return typeof _property=="string"?_element.style[_property]:_element.style;
      },
      getView:function(_element,_property){
        var view = document.defaultView?document.defaultView.getComputedStyle(_element,null):_element.currentStyle;
        _property = _property=="float"?pi.env.ie.toggle("styleFloat","cssFloat"):_property;
        if(_property=="opacity"&&pi.env.ie)
          return pi.util.Element.getOpacity(_element,view);
        return typeof _property=="string"?view[_property]:view;
      }
    },
    CloneObject:function(_object,_fn){
      var tmp = {};
      for(var key in _object)
      {
        if( pi.util.IsArray( _object[key] ) ){
          tmp[key] = Array.prototype.clone.apply( _object[key] );
        } else
          if( pi.util.IsHash( _object[key] ) ){
            tmp[ key ] = pi.util.CloneObject(_object[key]);
            if(_fn)_fn.call(tmp,key,_object);
          } else
            tmp[key] = _object[key];
      }
      return tmp;
    },
    MergeObjects:function(_object,_source){
      for(var key in _source){
        var value = _source[key];
        if (pi.util.IsArray(_source[key])) {
          if(pi.util.IsArray( _object[key] )){
            Array.prototype.push.apply( _source[key], _object[key] )
          }
          else
            value = _source[key].clone();
        }
        else 
          if (pi.util.IsHash(_source[key])) {
            if (pi.util.IsHash(_object[key])) {
              value = pi.util.MergeObjects(_object[key], _source[key]);
            } else {
              value = pi.util.CloneObject( _source[key] );
            }
          }
        _object[key] = value;
      };
      return _object;
    }
  };
  
  pi.get = function(){
    return document.getElementById(arguments[0]);
  };
  pi.get.byTag = function(){
    return document.getElementsByTagName(arguments[0]);
  };
  pi.get.byClass = function(){ return document.getElementsByClassName.apply(document,arguments); };
  
  pi.base = function(){
    this.body = {};
    this.constructor = null;
    
    this.build = function(_skipClonning){
      var base = this, skipClonning = _skipClonning||false, _private = {},
        fn = function(){
          var _p = pi.util.CloneObject(_private);
          if(!skipClonning){
            for(var key in this){
              
              if(pi.util.IsArray( this[ key ] ) ){
                this[key] = Array.prototype.clone.apply( this[key] );
              } else
                if( pi.util.IsHash(this[key]) ){
                  this[key] = pi.util.CloneObject( 
                    this[ key ],
                    function(_key,_object){
                      this[ _key ]._parent_ = this;
                    }
                  );
                  this[key]._parent_ = this;
                }
            }
          };
          base.createAccessors( _p, this );
          if(base.constructor)
            return base.constructor.apply(this,arguments);
          return this;
        };
      this.movePrivateMembers(this.body,_private);
      if(this.constructor){
        fn["$Constructor"] = this.constructor;
      }
      fn.prototype = this.body;
      return fn;
    };
    
    this.createAccessors = function(_p, _branch){
      var getter = function(_property){ return this[_property]; },
        setter = function(_property,_value){ this[_property] = _value; return _branch._parent_||_branch; };
  
      for (var name in _p) {
        var isPrivate = name.substring(0, 1) == "_", title = name.substring(1, 2).toUpperCase() + name.substring(2);
        if (isPrivate) {
          _branch["get" + title] = getter.curry(_p,name);
          _branch["set" + title] = setter.curry(_p,name);
        }
        else 
          if (pi.util.IsHash(_p[name])){
            if(!_branch[name])
              _branch[name] = {};
            this.createAccessors(_p[name], _branch[name]);
          }  
      };
    };
    
    this.movePrivateMembers = function(_object, _branch){
      for (var name in _object) {
        var isPrivate = name.substring(0, 1) == "_";
        
        if (isPrivate) {
          _branch[name] = _object[name];
          delete _object[name];
        }
        else 
          if (pi.util.IsHash(_object[name])){
            _branch[name] = {};
            this.movePrivateMembers(_object[name], _branch[name]);
          }
      };
    };
  };
  
  Function.prototype.extend = function(_prototype,_skipClonning){
    var object = new pi.base, superClass = this;
    if(_prototype["$Constructor"]){
      object.constructor = _prototype["$Constructor"];
      delete _prototype["$Constructor"];
    };
  
    object.body = superClass==pi.base?_prototype:pi.util.MergeObjects(_prototype,superClass.prototype,2);
    object.constructor=object.constructor||function(){
      if(superClass!=pi.base)
        superClass.apply(this,arguments);
    };
    
    return object.build(_skipClonning);
  };
  
  Function.prototype.curry = function(_scope){
    var fn = this, scope = _scope||window, args = Array.prototype.slice.call(arguments,1);
    return function(){ 
      return fn.apply(scope,args.concat( Array.prototype.slice.call(arguments,0) )); 
    };
  };
  
  pi.element = pi.base.extend({
    "$Constructor":function(_tag){
      this.environment.setElement(document.createElement(_tag||"DIV"));
      this.environment.getElement().pi = this;
      return this;
    },
    "clean":function(){
      var childs = this.child.get();
      while(childs.length){
        childs[0].parentNode.removeChild(childs[0]);
      }
    },
    "clone":function(_deep){
      return this.environment.getElement().cloneNode(_deep);
    },
    "insert":function(_element){
      _element = _element.environment?_element.environment.getElement():_element;
      _element.appendChild(this.environment.getElement());
      return this;
    },
    "insertAfter":function(_referenceElement){
      _referenceElement = _referenceElement.environment?_referenceElement.environment.getElement():_referenceElement;
      _referenceElement.nextSibling?this.insertBefore(_referenceElement.nextSibling):this.insert(_referenceElement.parentNode);
      return this;
    },
    "insertBefore":function(_referenceElement){
      _referenceElement = _referenceElement.environment?_referenceElement.environment.getElement():_referenceElement;
      _referenceElement.parentNode.insertBefore(this.environment.getElement(),_referenceElement);
      return this;
    },
    "query":function(_expression,_resultType,namespaceResolver,_result){
      return pi.xpath(_expression,_resultType||"ORDERED_NODE_SNAPSHOT_TYPE",this.environment.getElement(),_namespaceResolver,_result);
    },
    "remove":function(){
      this.environment.getParent().removeChild(
        this.environment.getElement()
      );
    },
    "update":function(_value){
        ["TEXTAREA","INPUT"].indexOf(this.environment.getName())>-1?
        (this.environment.getElement().value = _value):
        (this.environment.getElement().innerHTML = _value);
        return this;
    },
    "attribute":{
      "getAll":function(_name){
        return this._parent_.environment.getElement().attributes;
      },
      "clear":function(_name){
        this.set(_name,"");
        return this._parent_;
      },
      "get":function(_name){
        return this._parent_.environment.getElement().getAttribute(_name);
      },
      "has":function(_name){
        return pi.env.ie?(this.get(_name)!=null):this._parent_.environment.getElement().hasAttribute(_name);
      },
      "remove":function(_name){
        this._parent_.environment.getElement().removeAttribute(_name);
        return this._parent_;
      },
      "set":function(_name,_value){
        this._parent_.environment.getElement().setAttribute(_name,_value);
        return this._parent_;
      },
      "addClass":function(_classes){
        for (var i = 0; i < arguments.length; i++) {
          pi.util.Element.addClass(this._parent_.environment.getElement(),arguments[i]);
        };
        return this._parent_;
      },
      "clearClass":function(){
        this.setClass("");
        this._parent_;
      },
      "getClass":function(){
        return pi.util.Element.getClass( this._parent_.environment.getElement() );
      },
      "hasClass":function(_class){
        return pi.util.Element.hasClass( this._parent_.environment.getElement(), _class );
      },
      "setClass":function(_value){
        return pi.util.Element.setClass( this._parent_.environment.getElement(), _value );
      },
      "removeClass":function(_class){
        pi.util.Element.removeClass( this._parent_.environment.getElement(), _class );
        return this._parent_;
      },
      "toggleClass":function(_class){
        pi.util.Element.toggleClass( this._parent_.environment.getElement(), _class );
      }
    },
    "child":{
      "get":function(){
        return this._parent_.environment.getElement().childNodes;
      },
      "add":function(_elements){
        for (var i = 0; i < arguments.length; i++) {
          var el = arguments[i];
          this._parent_.environment.getElement().appendChild(
            el.environment ? el.environment.getElement() : el
          );
        }
        return this._parent_;
      },
      "addAfter":function(_element,_referenceElement){
        this.addBefore(
          _element.environment?_element.environment.getElement():_element,
          (_referenceElement.environment?_referenceElement.environment.getElement():_referenceElement).nextSibling
        );
        return this._parent_;
      },
      "addBefore":function(_element,_referenceElement){
        this._parent_.environment.getElement().insertBefore(
          _element.environment?_element.environment.getElement():_element,
          _referenceElement.environment?_referenceElement.environment.getElement():_referenceElement
        );
        return this._parent_;
      },
      "query":function(_tag,_attributeName,_attributeValue){
        return this._parent_.query(
          "{0}{1}".format( (_tag?"{0}".format(_tag):"/*"), _attributeName||_attributeValue?"[contains(concat(' ', @{0}, ' '),' {1} ')]".format(_attributeName||"",_attributeValue||""):"" )
        );
      },
      "remove":function(_element){
        this._parent_.environment.getElement().removeChild(_element.environment?_element.environment.getElement():_element);
      }
    },
    "environment":{
      "_element":null,
      "getParent":function(){
        return this.getElement().parentNode;
      },
      "getPosition":function(){
        return pi.util.Element.getPosition(this.getElement());
      },
      "getSize":function(){
        return pi.util.Element.getSize( this.getElement() );
      },
      "addStyle":function(_styleObject){
        pi.util.Element.addStyle(this.getElement(),_styleObject);
        return this._parent_;
      },
      "getStyle":function(_property){
        return pi.util.Element.getStyle(_property);
      },
      "getName":function(){
        return this.getElement().nodeName;
      },
      "getType":function(){
        return this.getElement().nodeType;
      },
      "getView":function(_property){
        return pi.util.Element.getView(this.getElement(),_property);
      }
    },
    "event":{
      "addListener":function(_event,_fn,_useCapture){
        pi.util.AddEvent(this._parent_.environment.getElement(),_event,_fn,_useCapture);
        return this._parent_;
      },
      "removeListener":function(_event,_fn,_useCapture){
        pi.util.RemoveEvent(this._parent_.environment.getElement(),_event,_fn,_useCapture);
        return this._parent_;
      }
    }
  });
  
  pi.xhr = new pi.base;
  pi.xhr.constructor = function(){
    var api;
    if(!window.XMLHttpRequest){
      var names = ["Msxml2.XMLHTTP.6.0","Msxml2.XMLHTTP.3.0","Msxml2.XMLHTTP","Microsoft.XMLHTTP"];
      for (var i = 0; i < names.length; i++) {
        try {
          this.environment.setApi(new ActiveXObject(names[i]));
          break;
        } catch (e) { continue; }
      }
    }
    else
      this.environment.setApi(new XMLHttpRequest());
    this.environment.getApi().onreadystatechange=this.event.readystatechange.curry(this);
    return this;
  };
  pi.xhr.body = {
    "abort":function(){
      this.environment.getApi().abort();
    },
    "send":function(){
      var url = this.environment.getUrl(), data = this.environment.getData(),dataUrl = ""; 

      for (var key in data)
        dataUrl += "{0}={1}&".format(key, data[key]);
        
      if (this.environment.getType()=="GET")
        url += (url.search("\\?")==-1?"?":"&")+"{0}".format(dataUrl);
      
      this.environment.getApi().open(this.environment.getType(),url,this.environment.getAsync());
      
      for(var key in this.environment.getHeader())
        this.environment.getApi().setRequestHeader(key,this.environment.getHeader()[key]);

      this.environment.getApi().send(this.environment.getType()=="GET"?"":dataUrl);
    }
  };
  pi.xhr.body.environment = {
    "_async":true, "_api":null, "_cache":true, "_callback":[], "_channel":null, "_data":{}, "_header":{}, "_mimeType":null, "_multipart":false, "_type":"GET", "_timeout":0, "_url":"",
    "addCallback": function(_options,_fn){
      this.getCallback().push({ "fn":_fn, "options":_options  });
    },
    "addHeader": function(_key,_value){
      this.getHeader()[_key] = _value;
    },
    "addData": function(_key,_value){
      this.getData()[_key] = _value;
    },
    "changeCache":function(_value){
      if(_value==false){
        this.addData("forceCache",Math.round(Math.random()*10000));
      }
      this.setCache(_value);
    },
    "changeType": function(_value){
      if(_value=="POST"){
        this.addHeader("Content-Type","application/x-www-form-urlencoded");
      }
      this.setType(_value);
    }
  };
  pi.xhr.body.event = {
    "readystatechange":function(){
      var readyState = this.environment.getApi().readyState;
      var callback=this.environment.getCallback();

      for (var i = 0; i < callback.length; i++) {
        if(callback[i].options.readyState.indexOf(readyState)>-1)
           callback[i].fn.apply(this);
      }
    }
  };
  pi.xhr = pi.xhr.build();
  
  /*
   * xml.xhr.get
   */
  
  pi.xhr.get = function(_url,_returnPiObject){
    var request = new pi.xhr();
    request.environment.setAsync(false);
    request.environment.setUrl(_url);
    request.send();
    return _returnPiObject?request:request.environment.getApi();
  };
  
  /*
   * pi.xpath
   */
  
  pi.xpath = function(_expression,_resultType,_contextNode,_namespaceResolver,_result){
    var contextNode = _contextNode||document, 
    expression = _expression||"",
    namespaceResolver = _namespaceResolver||null, 
    result=_result||null,
    resultType=_resultType||"ANY_TYPE";
    return document.evaluate(expression, contextNode, namespaceResolver, XPathResult[resultType], result);
  };
  
  Array.prototype.clone = function(){
    var tmp = [];
    Array.prototype.push.apply(tmp,this);
    tmp.forEach(function(item,index,object){
      if(item instanceof Array)
          object[index] = object[index].clone();
    });
      return tmp;
  };
  Array.prototype.count = function(_value){
    var count = 0;
    this.forEach(function(){
      count+=Number(arguments[0]==_value);
    });
    return count;
  };
  
  Array.prototype.forEach = Array.prototype.forEach||function(_function){
    for(var i=0; i<this.length; i++)
      _function.apply(this,[this[i],i,this]);
  };
  
  Array.prototype.getLastItem = function(){
    return this[this.length-1];
  };
  
  Array.prototype.indexOf = Array.prototype.indexOf||function(_value){
    var index = -1;
    for(var i=0; i<this.length; i++)
      if(this[i]==_value){
        index = i;
        break;
      }
    return index;
  };
  
  Array.prototype.remove = function(_index){
    var array = this.slice(0,_index);
    Array.prototype.push.apply(array,this.slice(_index+1));
    return array;
  };
  
  Array.prototype.removeValue = function(_value){
    return this.remove(this.indexOf(_value));
  };

  Boolean.prototype.toggle = function(){
    return this==true?arguments[0]:arguments[1];
  };

  Number.prototype.base = function(_system){
    var remain = this%_system;
    if(this==remain)return String.fromCharCode(this+(this>9?87:48));
    return ((this-remain)/_system).base(_system)+String.fromCharCode(remain+(remain>9?87:48));
  };
  Number.prototype.decimal = function(_system){
    var result = 0, digit = String(this).split("");
    for(var i=0; i<digit.length; i++)
    {
      digit[i]=parseInt((digit[i].charCodeAt(0)>58)?digit[i].charCodeAt(0)-87:digit[i]);
      result += digit[i]*(Math.pow(_system,digit.length-1-i));
    }
    return result;
  };
  Number.prototype.range = function(_pattern){
    for(
      var value = String(this), isFloat = /\./i.test(value), 
      i = isFloat.toggle(parseInt(value.split(".")[0]),0), 
      end = parseInt(value.split(".")[isFloat.toggle(1,0)]), 
      array = []; i<end; i++
    ){
      array.push(
        Boolean(_pattern)==false?i:(typeof _pattern=="function"?_pattern(i):_pattern[i])
      );
    }
    return array;
  };

  String.prototype.escape = function(){
    return escape(this);
  };

  String.prototype.format = function(){
    var values = arguments;
    return this.replace(/\{(\d)\}/g,function(){
      return values[arguments[1]];
    })
  };
  
  String.prototype.leftpad = function(_len,_ch){
    var str=this;
    var ch = Boolean(_ch)==false?" ":_ch;
    while(str.length<_len)
      str=ch+str;
    return str;
  };
  
  String.prototype.toggle = function(_value,_other){
    return this==_value?_value:_other;
  };
  
  String.prototype.unicode = function(){
    var str="", obj = this.split("");
    for(var i=obj.length-1; i>=0; i--)
      str="\\u{0}{1}".format(String(obj[i].charCodeAt(0).base(16)).leftpad(4,"0"),str);
    return str;
  };
  
  pi.util.AddEvent(
    pi.env.ie?window:document,
    pi.env.ie?"load":"DOMContentLoaded",
    function(){
      for(var i=0; i<pi.util.DOMContentLoaded.length; i++){
        pi.util.DOMContentLoaded[ i ]();
      }
    }
  );
  
})(window);